home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume23 / rc / part01 next >
Encoding:
Text File  |  1991-10-17  |  56.1 KB  |  2,228 lines
  1. Newsgroups: comp.sources.misc
  2. From: byron@archone.tamu.edu (Byron Rakitzis)
  3. Subject:  v23i061:  rc - A Plan 9 shell reimplementation, v1.2, Part01/06
  4. Message-ID: <csm-v23i061=rc.224128@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: a932f2a89d57b43a6a733a0325e502dd
  6. Date: Fri, 18 Oct 1991 03:42:31 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: byron@archone.tamu.edu (Byron Rakitzis)
  10. Posting-number: Volume 23, Issue 61
  11. Archive-name: rc/part01
  12. Environment: UNIX
  13. Supersedes: rc: Volume 20, Issue 10-13
  14.  
  15. This is version 1.2 of the rc shell.  rc is a command interpreter 
  16. and programming language similar to  sh(1).   It is  based on the 
  17. AT&T  plan 9 shell of the same  name.  The shell offers a  C-like 
  18. syntax (much more so than the C shell), and a  powerful mechanism 
  19. for manipulating variables. It is reasonably small and reasonably
  20. fast, especially when compared to contemporary shells. Its use is
  21. intended to be interactive, but the  language  lends  itself well 
  22. to scripts.
  23.  
  24. There's a mailing list for rc at rc@archone.tamu.edu. Send requests 
  25. to be added, etc. to rc-request@archone.tamu.edu.
  26.  
  27. Byron Rakitzis
  28. --------------
  29. #!/bin/sh
  30. # This is a shell archive (produced by shar 3.49)
  31. # To extract the files from this archive, save it to a file, remove
  32. # everything above the "!/bin/sh" line above, and type "sh file_name".
  33. #
  34. # existing files will NOT be overwritten unless -c is specified
  35. #
  36. # This is part 1 of a multipart archive                                    
  37. # do not concatenate these parts, unpack them in order with /bin/sh        
  38. #
  39. # This shar contains:
  40. # length  mode       name
  41. # ------ ---------- ------------------------------------------
  42. #   7545 -rw-r--r-- CHANGES
  43. #   1106 -rw-r--r-- COPYRIGHT
  44. #   5050 -rw-r--r-- EXAMPLES
  45. #   3536 -rw-r--r-- Makefile
  46. #   3366 -rw-r--r-- README
  47. #    408 -rw-r--r-- addon.c
  48. #   1101 -rw-r--r-- addon.h
  49. #  11200 -rw-r--r-- builtins.c
  50. #    191 -rw-r--r-- builtins.h
  51. #   5252 -rw-r--r-- cfix.awk
  52. #    546 -rw-r--r-- config.h
  53. #   2339 -rw-r--r-- except.c
  54. #    310 -rw-r--r-- except.h
  55. #   2671 -rw-r--r-- exec.c
  56. #    104 -rw-r--r-- exec.h
  57. #   2017 -rw-r--r-- execve.c
  58. #   5485 -rw-r--r-- fn.c
  59. #   9420 -rw-r--r-- footobar.c
  60. #    258 -rw-r--r-- footobar.h
  61. #   1619 -rw-r--r-- getopt.c
  62. #     98 -rw-r--r-- getopt.h
  63. #   6378 -rw-r--r-- glob.c
  64. #     66 -rw-r--r-- glob.h
  65. #   9512 -rw-r--r-- glom.c
  66. #    322 -rw-r--r-- glom.h
  67. #   6760 -rw-r--r-- hash.c
  68. #   1313 -rw-r--r-- hash.h
  69. #   3622 -rw-r--r-- heredoc.c
  70. #     97 -rw-r--r-- heredoc.h
  71. #    714 -rw-r--r-- hfix.awk
  72. #   4951 -rw-r--r-- history.1
  73. #   6420 -rw-r--r-- history.c
  74. #   7405 -rw-r--r-- input.c
  75. #    373 -rw-r--r-- input.h
  76. #    209 -rw-r--r-- jbwrap.h
  77. #  10411 -rw-r--r-- lex.c
  78. #    476 -rw-r--r-- lex.h
  79. #    984 -rw-r--r-- list.c
  80. #    119 -rw-r--r-- list.h
  81. #   2703 -rw-r--r-- main.c
  82. #   1992 -rw-r--r-- match.c
  83. #     46 -rw-r--r-- match.h
  84. #   1716 -rw-r--r-- mksignal
  85. #   2229 -rw-r--r-- nalloc.c
  86. #    323 -rw-r--r-- nalloc.h
  87. #    377 -rw-r--r-- node.h
  88. #    772 -rw-r--r-- open.c
  89. #     50 -rw-r--r-- open.h
  90. #     79 -rw-r--r-- parse.h
  91. #   5406 -rw-r--r-- parse.y
  92. #  67056 -rw-r--r-- plan9.ps
  93. #  35457 -rw-r--r-- rc.1
  94. #    654 -rw-r--r-- rc.h
  95. #   2480 -rw-r--r-- redir.c
  96. #     28 -rw-r--r-- redir.h
  97. #   3078 -rw-r--r-- status.c
  98. #    239 -rw-r--r-- status.h
  99. #    766 -rw-r--r-- stddef.h
  100. #    462 -rw-r--r-- stdlib.h
  101. #    516 -rw-r--r-- string.h
  102. #   4722 -rw-r--r-- tree.c
  103. #    132 -rw-r--r-- tree.h
  104. #    759 -rw-r--r-- unistd.h
  105. #   5782 -rw-r--r-- utils.c
  106. #    884 -rw-r--r-- utils.h
  107. #   6567 -rw-r--r-- var.c
  108. #    127 -rw-r--r-- version.c
  109. #   1660 -rw-r--r-- wait.c
  110. #    120 -rw-r--r-- wait.h
  111. #   8100 -rw-r--r-- walk.c
  112. #     59 -rw-r--r-- walk.h
  113. #   2816 -rw-r--r-- which.c
  114. #
  115. if test -r _shar_seq_.tmp; then
  116.     echo 'Must unpack archives in sequence!'
  117.     echo Please unpack part `cat _shar_seq_.tmp` next
  118.     exit 1
  119. fi
  120. # ============= CHANGES ==============
  121. if test -f 'CHANGES' -a X"$1" != X"-c"; then
  122.     echo 'x - skipping CHANGES (File already exists)'
  123.     rm -f _shar_wnt_.tmp
  124. else
  125. > _shar_wnt_.tmp
  126. echo 'x - extracting CHANGES (Text)'
  127. sed 's/^X//' << 'SHAR_EOF' > 'CHANGES' &&
  128. Changes since rc-1.0:
  129. X
  130. builtin now forces a path-search for non-builtin commands. e.g.,
  131. X
  132. X    builtin ls
  133. X
  134. forces a path search for /bin/ls, rather than running a function called
  135. "ls".
  136. X
  137. A bug in the builtin wait was fixed.
  138. X
  139. The builtin whatis how takes a -s flag, for displaying available
  140. signals and their handlers, and also prints correct code for
  141. reinterpretation.  (metacharacters inside variable names were not
  142. correctly quoted)
  143. X
  144. An extra field was added to the "limit" builtin for SunOS systems,
  145. which apparently allow a limit on file descriptors.
  146. X
  147. A home-rolled execve() was written for people with geriatric unices
  148. that don't do #! in the kernel.
  149. X
  150. SIGTERM is now ignored by rc along with SIGQUIT. (This is not how
  151. Duff's shell behaves, but it is standard practise for Unix shells to
  152. ignore SIGTERM)
  153. X
  154. If $history was set to a bad file, then rc would print far too many
  155. error messages.  Now rc prints one error message and assigns null to
  156. $history, if $history names an invalid file.
  157. X
  158. rc now explicitly refuses to trap SIGCLD on System V machines, because
  159. of the weird way in which SIGCLD work. (really because I didn't want to
  160. get into the job control business)
  161. X
  162. A bug was fixed in the parser so that functions with metacharacters in
  163. their names are correctly imported from the environment.
  164. X
  165. he globber was changed to call stat() before calling opendir();
  166. apparently opendir() succeeds on some Unices even when invoked on
  167. regular files.
  168. X
  169. It is now illegal to have '=' be part of a variable name. This should
  170. be the only illegal character inside a variable name!
  171. X
  172. backquote rescanning was rewritten from scratch; now it no longer
  173. assigns null list entries to represent consecutive occurences of $ifs
  174. characters in the input.
  175. X
  176. e.g., now `{echo '   '} returns a null list, and not a 4-element list
  177. of null characters.
  178. X
  179. rc used to export all handlers but those in {sighup, sigint, sigquit,
  180. sigterm, sigexit}.  Now rc does not export ANY signal handlers.
  181. X
  182. rc's lexer was cleaned up to accept 8-bit data. rc is now presumed to
  183. be 8-bit clean.  I would like to hear of evidence to the contrary.
  184. X
  185. rc now traps EOF when scanning a variable name inside a heredoc.
  186. X
  187. rc's fdgchar() was cleaned up so that it did not assign negative values
  188. to unsigned objects.  (this one is truly for the pedants)
  189. X
  190. rc's lexer was fixed so that multiple backslashes at the end of a line
  191. are interpreted correctly.
  192. X
  193. rc's parser now allows a newline to appear after "else" (via
  194. skipnl()).
  195. X
  196. main() was exiting in certain situations with an exit status of 0
  197. instead of rc's real exit status.
  198. X
  199. rc's yacc file was fixed so that yaccs which do "magic" can clean up
  200. after themselves via the tokens YYACCEPT and YYABORT. Most notably,
  201. Sun's yyparse() calls malloc.
  202. X
  203. A mistake in the argument list of treecpy() was cleaned up.
  204. X
  205. Calls to write() are now checked for failure.
  206. X
  207. walk() was optimized for space in two ways: rPIPE was removed and
  208. placed in a separate function body, and a few obvious chances for
  209. employing tail-recursion via goto's was taken. This should result in a
  210. slightly smaller use of stackspace.
  211. X
  212. Additions since 1.1beta:
  213. ------------------------
  214. X
  215. John Mackin kindly supplied a set of awk scripts to convert rc's
  216. source into K&R 1 C. To perform the conversion, type "make C".
  217. X
  218. Paul Haahr and I wrote a history program loosely based upon one
  219. that Boyd Roberts sent to me. Both of these programs are
  220. reimplementations of v8 shell history. Type "make history".
  221. X
  222. Tom Duff has kindly given permission for his paper "rc - a Shell
  223. for Plan 9 and UNIX Systems" to be distributed in PostScript form
  224. with my rc. The file is called "plan9-rc.ps".
  225. X
  226. Changes since 1.1beta:
  227. ----------------------
  228. X
  229. Builtins were changed to flag an error on too many arguments.
  230. Also, the shift builtin now complains if there are no more elements
  231. in $* to shift.
  232. X
  233. The error message printed by exec() ("foo not found") when it could
  234. not find an executable has been updated to read "Permission denied",
  235. and so on.
  236. X
  237. Bugs in the home-rolled execve() were fixed.
  238. X
  239. A compile-time option was added to rc so that rc exports environment
  240. variable names using only the character set [a-zA-Z0-9_]. This is for
  241. braindamaged Bourne shells which don't like characters like - or :
  242. appearing in variable names. rc does this by encoding the variable
  243. name in a hex-based code. It seems to work fine on systems which need
  244. it, but it's definitely a hack.
  245. X
  246. rc now supports /dev/fd, if you have it.
  247. X
  248. Occasionally rc would be too overzealous in its reporting of errors,
  249. so a failed call to write() would cause another failed call to
  250. write() (to print the error!!) and so on... Now rc no longer reports
  251. failed calls to write().
  252. Changes since 1.1gamma:
  253. X
  254. rc sorts the environment strings before exporting them
  255. X
  256. rc ignores signals on rc -c. Fixes the "rc -c sh" followed by an
  257. interrupt bug.
  258. X
  259. the bogus skipnl() action is gone from the parser; the optional
  260. newlines are implemented as yacc productions.
  261. X
  262. a bug in the function-printing code was fixed ( {echo}>file was
  263. exported incorrectly as {echo}>file () ).
  264. X
  265. a=1 {b=2} is now correctly executed as a local assignment to a and a
  266. global assignemnt to b, at the cost of a few extra braces in the
  267. printing of functions.
  268. X
  269. rc's use of jmp_buf was changed to work with braindamaged architectures
  270. which don't define jmp_buf as an array.
  271. X
  272. rc's access() was broken when uid == 0.
  273. X
  274. rc now incorporates switch--case parsing in the grammar; this means
  275. that the rules are a little more strict than they were before, but
  276. reasonable switch() statements should not break.
  277. X
  278. rc -n means don't execute commands, just parse.
  279. X
  280. eval statements now do not reset the line number count in scripts. This
  281. allows for more useful error messages, e.g.,
  282. X
  283. X    line 53: syntax error near end of line
  284. X
  285. as opposed to
  286. X
  287. X    line 1: syntax error near end of line
  288. X
  289. rc's non-exporting of variables like "pid" and "*" has been improved;
  290. it was previously not possible to export a function named "pid" or a
  291. variable named "sigint". This has been fixed.
  292. X
  293. rc's use of wait() was completely revamped. Now FIFOs should be more
  294. reliable, as should be signal handlers.
  295. X
  296. rc -x is now more informative: variable and function assignments are
  297. printed, as are calls to ~.
  298. X
  299. rc -nx now prints the parsetree of each command in addition to refusing
  300. to execute it.
  301. X
  302. for all it's worth, variables named "while" "switch" etc. are now
  303. correctly described by "whatis" (i.e., quoted).
  304. X
  305. for all it's worth, you can now return lists from functions, as long as
  306. each element is a valid exit status (integer, or lowercase signal name
  307. (with or without +core)) The most useful application for this would
  308. be:
  309. X
  310. X    fn foo {
  311. X        stuff
  312. X        stat = $status
  313. X        stuff
  314. X        return $stat
  315. X    }
  316. X
  317. here documents in loops and/or functions now interpret variable
  318. expansions at execute rather than at parse-time.
  319. X
  320. Changes since 1.1gamma:
  321. -----------------------
  322. X
  323. Several bugs were fixed. In particular:
  324. X
  325. When an exception in a braced group occurred, rc did not pop all local
  326. variable definitions.
  327. X
  328. returning from fn prompt would cause an infinite loop.
  329. X
  330. the postfix increment operator used for numbering the /tmp fifos that
  331. rc uses to implement <{} redirection was placed inside a cpp macro
  332. which evaluated an argument twice, and hence all fifos were named after
  333. odd integers. In the interest of fairness to the even integers, this
  334. has been corrected.
  335. X
  336. the man page has been cleaned up in countless ways.
  337. X
  338. rc -nx printed a redundant file-descriptor for "foo<{bar}"
  339. X
  340. "builtin exec sh" did not do the right thing, partly because exec is
  341. not a genuine builtin. However, now it does.
  342. SHAR_EOF
  343. chmod 0644 CHANGES ||
  344. echo 'restore of CHANGES failed'
  345. Wc_c="`wc -c < 'CHANGES'`"
  346. test 7545 -eq "$Wc_c" ||
  347.     echo 'CHANGES: original size 7545, current size' "$Wc_c"
  348. rm -f _shar_wnt_.tmp
  349. fi
  350. # ============= COPYRIGHT ==============
  351. if test -f 'COPYRIGHT' -a X"$1" != X"-c"; then
  352.     echo 'x - skipping COPYRIGHT (File already exists)'
  353.     rm -f _shar_wnt_.tmp
  354. else
  355. > _shar_wnt_.tmp
  356. echo 'x - extracting COPYRIGHT (Text)'
  357. sed 's/^X//' << 'SHAR_EOF' > 'COPYRIGHT' &&
  358. /*
  359. X * Copyright 1991 Byron Rakitzis.  All rights reserved.
  360. X *
  361. X * This software is not subject to any license of the American Telephone
  362. X * and Telegraph Company or of the Regents of the University of California.
  363. X *
  364. X * Permission is granted to anyone to use this software for any purpose on
  365. X * any computer system, and to alter it and redistribute it freely, subject
  366. X * to the following restrictions:
  367. X *
  368. X * 1. The author is not responsible for the consequences of use of this
  369. X *    software, no matter how awful, even if they arise from flaws in it.
  370. X *
  371. X * 2. The origin of this software must not be misrepresented, either by
  372. X *    explicit claim or by omission.  Since few users ever read sources,
  373. X *    credits must appear in the documentation.
  374. X *
  375. X * 3. Altered versions must be plainly marked as such, and must not be
  376. X *    misrepresented as being the original software.  Since few users
  377. X *    ever read sources, credits must appear in the documentation.
  378. X *
  379. X * 4. This notice may not be removed or altered.
  380. X *
  381. X *    [this copyright notice is adapted from Henry Spencer's
  382. X *    "awf" copyright notice.]
  383. X */
  384. SHAR_EOF
  385. chmod 0644 COPYRIGHT ||
  386. echo 'restore of COPYRIGHT failed'
  387. Wc_c="`wc -c < 'COPYRIGHT'`"
  388. test 1106 -eq "$Wc_c" ||
  389.     echo 'COPYRIGHT: original size 1106, current size' "$Wc_c"
  390. rm -f _shar_wnt_.tmp
  391. fi
  392. # ============= EXAMPLES ==============
  393. if test -f 'EXAMPLES' -a X"$1" != X"-c"; then
  394.     echo 'x - skipping EXAMPLES (File already exists)'
  395.     rm -f _shar_wnt_.tmp
  396. else
  397. > _shar_wnt_.tmp
  398. echo 'x - extracting EXAMPLES (Text)'
  399. sed 's/^X//' << 'SHAR_EOF' > 'EXAMPLES' &&
  400. There is no repository for useful rc code snippets as yet, so I'm including
  401. a (short) file in the distribution with some helpful/intriguing pieces of
  402. rc code.
  403. X
  404. A sample .rcrc
  405. --------------
  406. Here is the .rcrc I use on archone:
  407. X
  408. umask 022 
  409. path=(/bin /usr/bin /usr/ucb)
  410. ht=`/usr/arch/bin/hosttype
  411. h=$home
  412. history=$h/.history
  413. bin=$h/bin/$ht
  414. lib=$h/lib/$ht
  415. sh=$h/bin/sh
  416. include=$h/lib/include
  417. X
  418. switch ($ht) {
  419. case sun*
  420. X    OBERON='. '$h/other/oberon
  421. X    p=/usr/ucb
  422. X    compiler='gcc -Wall -O -g'
  423. X    MANPATH=$h/man:/usr/arch/man:/usr/man
  424. X    if (! ~ $TERM ()) {
  425. X        stty dec
  426. X        /usr/arch/bin/msgs -q
  427. X    }
  428. case next
  429. X    p=(/usr/ucb /usr/bin /NextApps)
  430. X    compiler='cc -Wall -O -g -DNODIRENT'
  431. X    MANPATH=$h/man:/usr/arch/man:/usr/man
  432. X    if (! ~ $TERM ())
  433. X        stty dec
  434. case sgi
  435. X    p=(/usr/ucb /usr/sbin /usr/bin)
  436. X    compiler='gcc -Wall -O -g -DNOSIGCLD'
  437. X    MANPATH=$h/man:/usr/arch/man:/usr/catman
  438. X    if (!{~ $TERM () || ~ $TERM *iris*})
  439. X        stty line 1 intr '' erase '' kill ''
  440. case *
  441. X    echo .rcrc not configured for this machine
  442. }
  443. X
  444. path=(. $sh $bin /usr/arch/bin $p /bin /usr/bin/X11 /etc /usr/etc)
  445. cdpath=(. .. $h $h/src $h/misc $h/other $h/adm)
  446. RNINIT=-d$h' -t -M -2400-h -2400+hfrom'; DOTDIR=$h/misc/news
  447. PRINTER=lw
  448. X
  449. fn s {
  450. X    echo $status
  451. }
  452. fn cd {
  453. X    builtin cd $1 && \
  454. X    switch ($1) {
  455. X    case ()
  456. X        dir=$home
  457. X    case *
  458. X        dir=()
  459. X    }
  460. }
  461. fn pwd {
  462. X    if (~ $dir ())
  463. X        dir=`/bin/pwd
  464. X    echo $dir
  465. }
  466. fn x {
  467. X    if (~ `tty /dev/console)
  468. X        clear_colormap
  469. X    clear
  470. X    exit
  471. }
  472. fn p {
  473. X    if (~ $history ()) {
  474. X        echo '$history not set' >[1=2]
  475. X        return 1
  476. X    }
  477. X
  478. X    if (! ~ $#* 0 1 2) {
  479. X        echo usage: $0 '[egrep pattern] [sed command]' >[1=2]
  480. X        return 1
  481. X    }
  482. X
  483. X    command=`{
  484. X        egrep -v '^[     ]*p([     ]+|$)' $history | switch ($#*) {
  485. X        case 0
  486. X            cat
  487. X        case 1
  488. X            egrep $1
  489. X        case 2
  490. X            egrep $1 | sed $2
  491. X        } | tail -1
  492. X    }
  493. X
  494. X    echo $command
  495. X    eval $command
  496. }
  497. X
  498. if (~ $TERM dialup network) {
  499. X    TERM=vt100
  500. X    biff y
  501. }
  502. X
  503. A front-end to NeXT's "openfile"
  504. --------------------------------
  505. X
  506. Named after the sam "B" command for opening a file, this script was written
  507. by Paul Haahr. (Assumes the "pick" command from Kernighan and Pike is also
  508. in your path.)
  509. X
  510. #!/bin/rc
  511. if (~ $#* 0)
  512. X        exec openfile
  513. create = ()
  514. files = ()
  515. for (i in $*)
  516. X        if (test -f $i) {
  517. X                files = ($files $i)
  518. X        } else {
  519. X                create = ($create $i)
  520. X    }
  521. create = `{ pick $create }
  522. files = ($files $create)
  523. for (i in $create)
  524. X        > $i
  525. if (! ~ $#files 0)
  526. X    openfile $files
  527. X
  528. A read function
  529. ---------------
  530. X
  531. Unlike sh, rc doesn't have a read. This clever alternative returns an
  532. exit status as well as fetch a variable. Use as
  533. X
  534. X    read foo
  535. X
  536. to set $foo to a single line from the terminal.
  537. X
  538. (due to John Mackin <john@syd.dit.csiro.au>)
  539. X
  540. fn read {
  541. X        x=() {
  542. X                x = `` ($nl) { awk '{print; print 0; exit}' ^ $nl ^ \
  543. X                                   'END {print 1; print 1}' }
  544. X                $1 = $x(1)
  545. X                return $x(2)
  546. X        }
  547. }
  548. X
  549. XFrom cs.wisc.edu!dws Fri Aug  2 18:16:14 1991
  550. X
  551. #-------
  552. # ls front end
  553. #-------
  554. fn ls    \
  555. {
  556. X    test -t 1 && * = (-FCb $*)
  557. X    builtin ls $*
  558. }
  559. #-------
  560. # nl - holds a newline, useful in certain command substitutions
  561. #-------
  562. nl='
  563. '
  564. #-------
  565. # show - tell me about a name
  566. #
  567. # Runs possibly dangerous things through cat -v in order to protect
  568. # me from the effects of control characters I might have in the
  569. # environment.
  570. #-------
  571. fn show    \
  572. {
  573. X    * = `` $nl {whatis -- $*}
  574. X    for(itis)
  575. X    {
  576. X        switch($^itis)
  577. X        {
  578. X        case 'fn '*    ; echo $itis | cat -v -t
  579. X        case builtin*    ; echo $itis
  580. X        case /*        ; file $itis; ls -ld $itis
  581. X        case *'='*    ; echo $itis | cat -v -t
  582. X        case *        ; echo $itis: UNKNOWN: update show
  583. X        }
  584. X    }
  585. X    itis = ()
  586. }
  587. #-------
  588. # Tell me automatically when a command has a nonzero status.
  589. #-------
  590. fn prompt    \
  591. {
  592. X    Status = $status
  593. X    ~ $Status 0 || echo '[status '$Status']'
  594. }
  595. X
  596. #-------
  597. # chop - echo the given list, less its final member
  598. #
  599. # e.g. chop (a b c) -> (a b)
  600. #-------
  601. fn chop {
  602. X    ~ $#* 0 1 && return 0
  603. X    ans = '' {    # local variable
  604. X        ans = ()
  605. X        while(! ~ $#* 1)
  606. X        {
  607. X            ans = ($ans $1)
  608. X            shift
  609. X        }
  610. X        echo $ans
  611. X    }
  612. }
  613. X
  614. XFrom arnold@audiofax.com Thu May 30 08:49:51 1991
  615. X
  616. # cd.rc --- souped up version of cd
  617. X
  618. # this is designed to emulate the fancy version of cd in ksh,
  619. # so if you're a purist, feel free to gag
  620. X
  621. _cwd=$home
  622. _oldcwd=$home
  623. X
  624. fn cd {
  625. X    if (~ $#* 0) {
  626. X        if (~ $_cwd $home) {    # do nothing
  627. X        } else {
  628. X            builtin cd && { _oldcwd=$_cwd ; _cwd=$home }
  629. X        }
  630. X    } else if (~ $#* 1) {
  631. X        if (~ $1 -) {
  632. X            _t=$_cwd
  633. X            builtin cd $_oldcwd && {
  634. X                _cwd=$_oldcwd
  635. X                _oldcwd=$_t
  636. X                echo $_cwd
  637. X            }
  638. X            _t=()
  639. X        } else {
  640. X            # if a cd happens through the cdpath, rc echos
  641. X            # the directory on its own.  all we have to do
  642. X            # is track where we end up
  643. X            _dopwd = 1
  644. X            { ~ $1 /* } && _dopwd = 0    # absolute path
  645. X            builtin cd $1 && {
  646. X                _oldcwd=$_cwd
  647. X                _cwd=$1
  648. X                { ~ $_dopwd 1 } && _cwd=`/bin/pwd
  649. X            }
  650. X            _dopwd=()
  651. X        }
  652. X    } else if (~ $#* 2) {
  653. X        _t=`{ echo $_cwd | sed 's<'$1'<'$2'<' }
  654. X        builtin cd $_t && {
  655. X            _oldcwd=$_cwd
  656. X            _cwd=$_t
  657. X            echo $_cwd
  658. X        }
  659. X        _t=()
  660. X    } else {
  661. X        echo cd: takes 0, 1, or 2 arguments >[1=2]
  662. X        builtin cd $1 && { _oldcwd=$_cwd ; _cwd=`/bin/pwd ; echo $_cwd }
  663. X    }
  664. }
  665. X
  666. fn pwd { echo $_cwd }
  667. X
  668. SHAR_EOF
  669. chmod 0644 EXAMPLES ||
  670. echo 'restore of EXAMPLES failed'
  671. Wc_c="`wc -c < 'EXAMPLES'`"
  672. test 5050 -eq "$Wc_c" ||
  673.     echo 'EXAMPLES: original size 5050, current size' "$Wc_c"
  674. rm -f _shar_wnt_.tmp
  675. fi
  676. # ============= Makefile ==============
  677. if test -f 'Makefile' -a X"$1" != X"-c"; then
  678.     echo 'x - skipping Makefile (File already exists)'
  679.     rm -f _shar_wnt_.tmp
  680. else
  681. > _shar_wnt_.tmp
  682. echo 'x - extracting Makefile (Text)'
  683. sed 's/^X//' << 'SHAR_EOF' > 'Makefile' &&
  684. # Makefile for rc.
  685. X
  686. # Check the definitions in stddef.h and the configuration parameters below
  687. # to make sure they are correct for your system.
  688. X
  689. # Configuration parameters for rc:
  690. # 
  691. # Configurations may be added or deleted using ed; e.g., the ed command
  692. # for adding the NODIRENT configuration would be
  693. # 
  694. # /#NODIRENT/s/^.//
  695. #
  696. # Note that config.h automatically sets up configurations for some
  697. # systems.
  698. X
  699. # Define the macro NODIRENT if your system has <sys/dir.h> but not
  700. # <dirent.h>. (e.g., NeXT-OS)
  701. #NODIRENT    = -DNODIRENT
  702. X
  703. # Define the macro DEVFD if your system supports /dev/fd.
  704. #DEVFD        = -DDEVFD
  705. X
  706. # Define the macro NOLIMITS if your system does not support Berkeley
  707. # limits.
  708. #NOLIMITS    = -DNOLIMITS
  709. X
  710. # Define the macro NOSIGCLD if your system uses SIGCLD in the System
  711. # V way. (e.g., Irix)
  712. #NOSIGCLD    = -DNOSIGCLD
  713. X
  714. # Define the macro READLINE if you want rc to call GNU readline
  715. # instead of read(2) on interactive shells.
  716. #READLINE    = -DREADLINE
  717. X
  718. # Define the macro NOEXECVE if your Unix does not interpret #! in the
  719. # kernel, and set EXECVE to execve.o.
  720. #NOEXECVE    = -DNOEXECVE
  721. #EXECVE        = execve.o
  722. X
  723. # Define the macro ADDON if you wish to extend rc via locally-defined
  724. # builtins. An interface is provided in addon.[ch]. Note that the author
  725. # does not endorse any such extensions, rather hopes that this way
  726. # rc will become useful to more people.
  727. #ADDON        = addon.o
  728. X
  729. # If you want rc to default to some interpreter for files which don't
  730. # have a legal #! on the first line, define the macro DEFAULTINTERP.
  731. #DEFAULTINTERP    = -DDEFAULTINTERP=\"/bin/sh\"
  732. X
  733. # If your /bin/sh (or another program you care about) rejects
  734. # environment variables with special characters in them, rc can put
  735. # out ugly variable names using [_0-9a-zA-Z] that encode the real
  736. # name; define PROTECT_ENV for this hack.
  737. #PROTECT_ENV    = -DPROTECT_ENV
  738. X
  739. # If your window system has a broken terminal emulator (and I'm talking
  740. # specifically about the NeXT here) which expects your shell to do csh-
  741. # like job control stuff on startup, define PROTECT_JOB so that rc can
  742. # do the "right" thing.
  743. #PROTECT_JOB    = -DPROTECT_JOB
  744. X
  745. CONFIG = $(NODIRENT) $(NOCMDARG) $(DEVFD) $(NOLIMITS) $(NOSIGCLD) \
  746. X    $(READLINE) $(NOEXECVE)    $(DEFAULTINTERP) $(PROTECT_ENV) $(PROTECT_JOB)
  747. X
  748. # Use an ANSI compiler (or at least one that groks prototypes and void *):
  749. CC=gcc -g -O
  750. CFLAGS=$(CONFIG)
  751. LDFLAGS=
  752. X
  753. # Use bison if you will, but yacc generates a smaller y.tab.c, and the speed
  754. # of the parser is largely irrelevant in a shell.
  755. YACC=yacc
  756. X
  757. OBJS =  $(ADDON) builtins.o except.o exec.o $(EXECVE) fn.o footobar.o getopt.o \
  758. X    glob.o glom.o hash.o heredoc.o input.o lex.o list.o main.o match.o \
  759. X    nalloc.o open.o redir.o sigmsgs.o status.o tree.o utils.o var.o \
  760. X    version.o wait.o walk.o which.o y.tab.o
  761. X
  762. # If rc is compiled with GNU readline, you must supply the correct arguments to
  763. # ld on this line. Typically this would be something like:
  764. #
  765. #    $(CC) -o rc $(OBJS) -lreadline -ltermcap
  766. X
  767. rc: $(OBJS)
  768. X    $(CC) -o rc $(OBJS)
  769. X
  770. sigmsgs.c: mksignal
  771. X    sh mksignal /usr/include/sys/signal.h
  772. X
  773. y.tab.c: parse.y
  774. X    $(YACC) -d parse.y
  775. X
  776. clean:
  777. X    rm -f a.* *.o *.s core *.tab.* *.out
  778. X
  779. history: history.c
  780. X    $(CC) -o ./- history.c
  781. X    rm -f ./-- ./-p ./--p
  782. X    ln -s ./- ./--
  783. X    ln -s ./- ./-p
  784. X    ln -s ./- ./--p
  785. X
  786. C: force
  787. X    -mkdir C
  788. X    for i in *.c; do awk -f cfix.awk $$i >C/$$i; done
  789. X    for i in *.h; do awk -f hfix.awk $$i >C/$$i; done
  790. X    sed 's/CFLAGS=/&-Dconst= /' Makefile > C/Makefile
  791. X    cp mksignal *.y C
  792. X
  793. force:
  794. X
  795. # dependencies:
  796. X
  797. sigmsgs.h: sigmsgs.c
  798. lex.o y.tab.o: y.tab.c
  799. builtins.c fn.c status.c hash.c: sigmsgs.h
  800. SHAR_EOF
  801. chmod 0644 Makefile ||
  802. echo 'restore of Makefile failed'
  803. Wc_c="`wc -c < 'Makefile'`"
  804. test 3536 -eq "$Wc_c" ||
  805.     echo 'Makefile: original size 3536, current size' "$Wc_c"
  806. rm -f _shar_wnt_.tmp
  807. fi
  808. # ============= README ==============
  809. if test -f 'README' -a X"$1" != X"-c"; then
  810.     echo 'x - skipping README (File already exists)'
  811.     rm -f _shar_wnt_.tmp
  812. else
  813. > _shar_wnt_.tmp
  814. echo 'x - extracting README (Text)'
  815. sed 's/^X//' << 'SHAR_EOF' > 'README' &&
  816. This is release 1.2 of rc.
  817. X
  818. Read COPYRIGHT for copying information. All files are
  819. X
  820. Copyright 1991, Byron Rakitzis.
  821. X
  822. COMPILING
  823. X
  824. rc was written in portable ANSI C. For those without gcc or some other
  825. compiler which groks prototypes and (void *), there is a set of awk
  826. scripts which convert the source into old-style C. To do this, type
  827. "make C". This is a nondestructive operation; the new code will be
  828. placed in a subdirectory called "C".
  829. X
  830. Please read the Makefile, and make sure that the configuration parameters
  831. are appropriate for your system. Also, look at config.h and stddef.h.
  832. X
  833. To compile the history program, type "make history". This will create
  834. 1 binary and three soft links pointing at the binary. They are respectively
  835. named -, --, -p and --p.
  836. X
  837. BUGS
  838. X
  839. Send bug reports to byron@archone.tamu.edu. If a core dump is
  840. generated, sending me a backtrace will help me out a great deal. You
  841. can get a backtrace like this:
  842. X
  843. X    ; gdb rc core
  844. X    (gdb) where
  845. X    <<<BACKTRACE INFO>>>
  846. X    (gdb)
  847. X
  848. Also, always report the machine, compiler and OS used to make rc.  It's
  849. possible I may have access to a machine of that type, in which case it
  850. becomes much easier for me to track the bug down.
  851. X
  852. If you are using gcc, please make sure that you have a recent version of
  853. the compiler (1.39 and up) before you send me a note; I have found that
  854. older versions of gcc choke over rc and generate bad code on several
  855. architectures.
  856. X
  857. MAN PAGE
  858. X
  859. The man page works with nroff on my Sun, but I had to use groff in
  860. order to get the man page typeset for a laser printer. I am assuming
  861. that ditroff will also format rc.1 correctly for a printer. If anyone
  862. can tell me how to get BSD troff to do this, I would be grateful.
  863. X
  864. FEEPING CREATURISM
  865. X
  866. See the end of the man page, under "INCOMPATABILITIES" for (known?)
  867. differences from the "real" rc. Most of these changes were necessary
  868. to get rc to work in a reasonable fashion on a real UNIX system; a
  869. few were changes motivated by concern about some inadequacies in
  870. the original design.
  871. X
  872. CREDITS
  873. X
  874. This shell was written by me, Byron Rakitzis, but kudos go to Paul
  875. Haahr for letting me know what a shell should do and for contributing
  876. certain bits and pieces to rc (notably the limits code, most of which.c
  877. and the backquote redirection code), and to Hugh Redelmeier for running
  878. rc through his fussy ANSI compiler and thereby provoking interesting
  879. discussions about portability, and also for providing many valuable
  880. suggestions for improving rc's code in general. Finally, many thanks
  881. go to David Sanderson, for reworking the man page to format well with
  882. troff, and for providing many suggestions both for rc and its man page.
  883. X
  884. Thanks to Boyd Roberts for the original history.c, and to Hugh again
  885. for re-working parts of that code.
  886. X
  887. Of course, without Tom Duff's design of the original rc, I could not
  888. have written this shell (though I probably would have written *a*
  889. shell). Almost of all of the features, with minor exceptions, have been
  890. implemented as described in the Unix v10 manuals. Hats off to td for
  891. designing a C-like, minimal but very useful shell.
  892. X
  893. Tom Duff has kindly given permission for the paper he wrote for UKUUG
  894. to be distributed with this version of rc (called "plan9.ps"). Please
  895. read this paper bearing in mind that it describes a program that was
  896. written at AT&T and that the version of rc presented here differs in some
  897. respects.
  898. SHAR_EOF
  899. chmod 0644 README ||
  900. echo 'restore of README failed'
  901. Wc_c="`wc -c < 'README'`"
  902. test 3366 -eq "$Wc_c" ||
  903.     echo 'README: original size 3366, current size' "$Wc_c"
  904. rm -f _shar_wnt_.tmp
  905. fi
  906. # ============= addon.c ==============
  907. if test -f 'addon.c' -a X"$1" != X"-c"; then
  908.     echo 'x - skipping addon.c (File already exists)'
  909.     rm -f _shar_wnt_.tmp
  910. else
  911. > _shar_wnt_.tmp
  912. echo 'x - extracting addon.c (Text)'
  913. sed 's/^X//' << 'SHAR_EOF' > 'addon.c' &&
  914. /*
  915. X   This file contains the implementations of any locally defined
  916. X   builtins.
  917. */
  918. X
  919. #ifdef    DWS
  920. X
  921. /*
  922. X   This is what DaviD Sanderson (dws@cs.wisc.edu) uses.
  923. */
  924. X
  925. #include <sys/types.h>
  926. #include <sys/file.h>
  927. #include <sys/stat.h>
  928. X
  929. #include "rc.h"        /* for boolean TRUE, FALSE */
  930. #include "status.h"    /* for set() */
  931. #include "addon.h"
  932. #include "utils.h"
  933. X
  934. #include "addon/access.c"
  935. #include "addon/test.c"
  936. X
  937. #endif
  938. SHAR_EOF
  939. chmod 0644 addon.c ||
  940. echo 'restore of addon.c failed'
  941. Wc_c="`wc -c < 'addon.c'`"
  942. test 408 -eq "$Wc_c" ||
  943.     echo 'addon.c: original size 408, current size' "$Wc_c"
  944. rm -f _shar_wnt_.tmp
  945. fi
  946. # ============= addon.h ==============
  947. if test -f 'addon.h' -a X"$1" != X"-c"; then
  948.     echo 'x - skipping addon.h (File already exists)'
  949.     rm -f _shar_wnt_.tmp
  950. else
  951. > _shar_wnt_.tmp
  952. echo 'x - extracting addon.h (Text)'
  953. sed 's/^X//' << 'SHAR_EOF' > 'addon.h' &&
  954. /*
  955. X   This file is the interface to the rest of rc for any locally
  956. X   defined addon builtins.  By default there are none.
  957. X   The interface consists of the following macros.
  958. X  
  959. X   ADDON_FUN    A comma-separated list of the function names for the
  960. X          builtins.
  961. X  
  962. X   ADDON_STR    A comma-separated list of string literals corresponding
  963. X          to the function names in ADDON_FUN.
  964. X  
  965. X   The addon functions must also have proper prototypes in this file.
  966. X   The builtins all have the form:
  967. X  
  968. X      void b_NAME(char **av);
  969. X  
  970. X   Builtins report their exit status using set(TRUE) or set(FALSE).
  971. X  
  972. X   Example:
  973. X  
  974. X      #define ADDON_FUN    b_test, b_printf
  975. X      #define ADDON_STR    "test", "printf"
  976. X      extern void b_test(char **av);
  977. X      extern void b_printf(char **av);
  978. */
  979. X
  980. #define ADDON_FUN    /* no addons by default */
  981. #define ADDON_STR    /* no addons by default */
  982. X
  983. #ifdef    DWS
  984. X
  985. /*
  986. X   This is what DaviD Sanderson (dws@cs.wisc.edu) uses.
  987. */
  988. X
  989. #undef    ADDON_FUN
  990. #define ADDON_FUN    b_access, b_test, b_test
  991. #undef    ADDON_STR
  992. #define ADDON_STR    "access", "test", "["
  993. X
  994. extern void b_access(char **av);
  995. extern void b_test(char **av);
  996. X
  997. #endif
  998. SHAR_EOF
  999. chmod 0644 addon.h ||
  1000. echo 'restore of addon.h failed'
  1001. Wc_c="`wc -c < 'addon.h'`"
  1002. test 1101 -eq "$Wc_c" ||
  1003.     echo 'addon.h: original size 1101, current size' "$Wc_c"
  1004. rm -f _shar_wnt_.tmp
  1005. fi
  1006. # ============= builtins.c ==============
  1007. if test -f 'builtins.c' -a X"$1" != X"-c"; then
  1008.     echo 'x - skipping builtins.c (File already exists)'
  1009.     rm -f _shar_wnt_.tmp
  1010. else
  1011. > _shar_wnt_.tmp
  1012. echo 'x - extracting builtins.c (Text)'
  1013. sed 's/^X//' << 'SHAR_EOF' > 'builtins.c' &&
  1014. /* builtins.c: the collection of rc's builtin commands */
  1015. X
  1016. /*
  1017. X    NOTE: rc's builtins do not call "rc_error" because they are
  1018. X    commands, and rc errors usually arise from syntax errors. e.g.,
  1019. X    you probably don't want interpretation of a shell script to stop
  1020. X    because of a bad umask.
  1021. */
  1022. X
  1023. #include "jbwrap.h"
  1024. #include <errno.h>
  1025. #include "rc.h"
  1026. #ifndef NOLIMITS
  1027. #include <sys/time.h>
  1028. #include <sys/resource.h>
  1029. #endif
  1030. #include "utils.h"
  1031. #include "walk.h"
  1032. #include "input.h"
  1033. #include "builtins.h"
  1034. #include "hash.h"
  1035. #include "nalloc.h"
  1036. #include "status.h"
  1037. #include "footobar.h"
  1038. #include "lex.h"
  1039. #include "open.h"
  1040. #include "except.h"
  1041. #include "redir.h"
  1042. #include "glom.h"
  1043. #include "tree.h"
  1044. #include "sigmsgs.h"
  1045. #include "getopt.h"
  1046. #include "wait.h"
  1047. #include "addon.h"
  1048. X
  1049. extern int umask(int);
  1050. X
  1051. static void b_break(char **), b_cd(char **),
  1052. X    b_echo(char **), b_eval(char **), b_exit(char **), b_limit(char **),
  1053. X    b_return(char **), b_shift(char **), b_umask(char **), b_wait(char **),
  1054. X    b_whatis(char **);
  1055. X
  1056. static builtin_t *const builtins[] = {
  1057. X    b_break, b_builtin, b_cd, b_echo, b_eval, b_exec, b_exit,
  1058. X    b_limit, b_return, b_shift, b_umask, b_wait, b_whatis, b_dot,
  1059. X    ADDON_FUN
  1060. };
  1061. X
  1062. static char *const builtins_str[] = {
  1063. X    "break", "builtin", "cd", "echo", "eval", "exec", "exit",
  1064. X    "limit", "return", "shift", "umask", "wait", "whatis", ".",
  1065. X    ADDON_STR
  1066. };
  1067. X
  1068. builtin_t *isbuiltin(char *s) {
  1069. X    int i;
  1070. X
  1071. X    for (i = 0; i < arraysize(builtins_str); i++)
  1072. X        if (streq(builtins_str[i], s))
  1073. X            return builtins[i];
  1074. X    return NULL;
  1075. }
  1076. X
  1077. /* funcall() is the wrapper used to invoke shell functions. pushes $*, and "return" returns here. */
  1078. X
  1079. void funcall(char **av) {
  1080. X    jbwrap j;
  1081. X    Estack e1, e2;
  1082. X
  1083. X    if (setjmp(j.j))
  1084. X        return;
  1085. X
  1086. X    starassign(*av, av+1, TRUE);
  1087. X    except(RETURN, &j, &e1);
  1088. X    except(VARSTACK, "*", &e2);
  1089. X    walk(treecpy(fnlookup(*av),nalloc), TRUE);
  1090. X    varrm("*", TRUE);
  1091. X    unexcept(); /* VARSTACK */
  1092. X    unexcept(); /* RETURN */
  1093. }
  1094. X
  1095. static void arg_count(char *name) {
  1096. X    fprint(2, "too many arguments to %s\n", name);
  1097. X    set(FALSE);
  1098. }
  1099. X
  1100. static void badnum(char *num) {
  1101. X    fprint(2, "%s is a bad number", num);
  1102. X    set(FALSE);
  1103. }
  1104. X
  1105. /* a dummy command. (exec() performs "exec" simply by not forking) */
  1106. X
  1107. void b_exec(char **av) {
  1108. }
  1109. X
  1110. /* echo -n omits a newline. echo -- -n echos '-n' */
  1111. X
  1112. static void b_echo(char **av) {
  1113. X    SIZE_T i;
  1114. X    char *format = "%a\n";
  1115. X
  1116. X    if (*++av != NULL) {
  1117. X        if (streq(*av, "-n")) {
  1118. X            format = "%a";
  1119. X            av++;
  1120. X        } else if (streq(*av, "--")) {
  1121. X            av++;
  1122. X        }
  1123. X    }
  1124. X
  1125. X    i = strarraylen(av) + 1; /* one for the null terminator */
  1126. X
  1127. X    if (i < FPRINT_SIZE)
  1128. X        fprint(1, format, av);
  1129. X    else
  1130. X        writeall(1, sprint(nalloc(i), format, av), i-1);
  1131. X    set(TRUE);
  1132. }
  1133. X
  1134. /* cd. traverse $cdpath if the directory given is not an absolute pathname */
  1135. X
  1136. static void b_cd(char **av) {
  1137. X    List *s, nil;
  1138. X    char *path = NULL;
  1139. X    SIZE_T t, pathlen = 0;
  1140. X
  1141. X    if (*++av == NULL) {
  1142. X        s = varlookup("home");
  1143. X        *av = (s == NULL) ? "/" : s->w;
  1144. X    } else if (av[1] != NULL) {
  1145. X        arg_count("cd");
  1146. X        return;
  1147. X    }
  1148. X
  1149. X    if (isabsolute(*av)) { /* absolute pathname? */
  1150. X        if (chdir(*av) < 0) {
  1151. X            set(FALSE);
  1152. X            uerror(*av);
  1153. X        } else
  1154. X            set(TRUE);
  1155. X    } else {
  1156. X        s = varlookup("cdpath");
  1157. X        if (s == NULL) {
  1158. X            s = &nil;
  1159. X            nil.w = "";
  1160. X            nil.n = NULL;
  1161. X        }
  1162. X        do {
  1163. X            if (s != &nil && *s->w != '\0') {
  1164. X                t = strlen(*av) + strlen(s->w) + 2;
  1165. X                if (t > pathlen)
  1166. X                    path = nalloc(pathlen = t);
  1167. X                strcpy(path, s->w);
  1168. X                strcat(path, "/");
  1169. X                strcat(path, *av);
  1170. X            } else {
  1171. X                pathlen = 0;
  1172. X                path = *av;
  1173. X            }
  1174. X            if (chdir(path) >= 0) {
  1175. X                set(TRUE);
  1176. X                if (interactive && *s->w != '\0' && !streq(s->w,"."))
  1177. X                    fprint(1,"%s\n",path);
  1178. X                return;
  1179. X            }
  1180. X            s = s->n;
  1181. X        } while (s != NULL);
  1182. X        fprint(2,"couldn't cd to %s\n", *av);
  1183. X        set(FALSE);
  1184. X    }
  1185. }
  1186. X
  1187. static void b_umask(char **av) {
  1188. X    int i;
  1189. X
  1190. X    if (*++av == NULL) {
  1191. X        set(TRUE);
  1192. X        i = umask(0);
  1193. X        umask(i);
  1194. X        fprint(1, "0%o\n", i);
  1195. X    } else if (av[1] == NULL) {
  1196. X        i = o2u(*av);
  1197. X        if ((unsigned int) i > 0777) {
  1198. X            fprint(2,"bad umask\n");
  1199. X            set(FALSE);
  1200. X        } else {
  1201. X            umask(i);
  1202. X            set(TRUE);
  1203. X        }
  1204. X    } else {
  1205. X        arg_count("umask");
  1206. X        return;
  1207. X    }
  1208. }
  1209. X
  1210. static void b_exit(char **av) {
  1211. X    int s;
  1212. X
  1213. X    if (av[1] == NULL)
  1214. X        rc_exit(getstatus());
  1215. X    if (av[2] != NULL) {
  1216. X        fprint(2, "exit: too many arguments\n");
  1217. X        rc_exit(1);
  1218. X    }
  1219. X    if ((s = a2u(av[1])) >= 0)
  1220. X        rc_exit(s);
  1221. X    badnum(av[1]);
  1222. X    rc_exit(1);
  1223. }
  1224. X
  1225. /* raise a "return" exception, i.e., return from a function. if an integer argument is present, set $status to it */
  1226. X
  1227. static void b_return(char **av) {
  1228. X    if (av[1] != NULL)
  1229. X        ssetstatus(av + 1);
  1230. X    rc_raise(RETURN);
  1231. }
  1232. X
  1233. /* raise a "break" exception for breaking out of for and while loops */
  1234. X
  1235. static void b_break(char **av) {
  1236. X    if (av[1] != NULL) {
  1237. X        arg_count("break");
  1238. X        return;
  1239. X    }
  1240. X    rc_raise(BREAK);
  1241. }
  1242. X
  1243. /* shift $* n places (default 1) */
  1244. X
  1245. static void b_shift(char **av) {
  1246. X    int shift;
  1247. X    List *s, *dollarzero;
  1248. X
  1249. X    shift = (av[1] == NULL ? 1 : a2u(av[1]));
  1250. X
  1251. X    if (av[1] != NULL && av[2] != NULL) {
  1252. X        arg_count("shift");
  1253. X        return;
  1254. X    }
  1255. X
  1256. X    if (shift < 0) {
  1257. X        badnum(av[1]);
  1258. X        return;
  1259. X    }
  1260. X
  1261. X    s = varlookup("*")->n;
  1262. X    dollarzero = varlookup("0");
  1263. X
  1264. X    while (s != NULL && shift != 0) {
  1265. X        s = s->n;
  1266. X        --shift;
  1267. X    }
  1268. X
  1269. X    if (s == NULL && shift != 0) {
  1270. X        fprint(2,"cannot shift\n");
  1271. X        set(FALSE);
  1272. X    } else {
  1273. X        varassign("*", append(dollarzero, s), FALSE);
  1274. X        set(TRUE);
  1275. X    }
  1276. }
  1277. X
  1278. /* dud function */
  1279. X
  1280. void b_builtin(char **av) {
  1281. }
  1282. X
  1283. /* wait for a given process, or all outstanding processes */
  1284. X
  1285. static void b_wait(char **av) {
  1286. X    int stat, pid;
  1287. X
  1288. X    if (av[1] == NULL) {
  1289. X        waitforall(&stat);
  1290. X        setstatus(stat);
  1291. X        return;
  1292. X    }
  1293. X
  1294. X    if (av[2] != NULL) {
  1295. X        arg_count("wait");
  1296. X        return;
  1297. X    }
  1298. X
  1299. X    if ((pid = a2u(av[1])) < 0) {
  1300. X        badnum(av[1]);
  1301. X        return;
  1302. X    }
  1303. X
  1304. X    if (rc_wait4(pid, &stat) > 0)
  1305. X        setstatus(stat);
  1306. X    else
  1307. X        set(FALSE);
  1308. }
  1309. X
  1310. /*
  1311. X   whatis without arguments prints all variables and functions. Otherwise, check to see if a name
  1312. X   is defined as a variable, function or pathname.
  1313. */
  1314. X
  1315. static void b_whatis(char **av) {
  1316. X    enum bool f,found;
  1317. X    int i,j,ac,c;
  1318. X    List *s;
  1319. X    Node *n;
  1320. X    char *e;
  1321. X    boolean ess = FALSE;
  1322. X
  1323. X    optind = 0;
  1324. X    for (ac = 0; av[ac] != NULL; ac++)
  1325. X        ; /* count the arguments for getopt */
  1326. X
  1327. X    while ((c = getopt(ac, av, "s")) != -1)
  1328. X        switch (c) {
  1329. X        case 's':
  1330. X            ess = TRUE;
  1331. X            break;
  1332. X        case '?':
  1333. X            set(FALSE);
  1334. X            return;
  1335. X        }
  1336. X
  1337. X    av += optind;
  1338. X
  1339. X    if (*av == NULL && !ess) {
  1340. X        whatare_all_vars();
  1341. X        set(TRUE);
  1342. X        return;
  1343. X    }
  1344. X
  1345. X    if (ess)
  1346. X        whatare_all_signals();
  1347. X
  1348. X    found = TRUE;
  1349. X
  1350. X    for (i = 0; av[i] != NULL; i++) {
  1351. X        f = FALSE;
  1352. X        errno = ENOENT;
  1353. X        if ((s = varlookup(av[i])) != NULL) {
  1354. X            f = TRUE;
  1355. X            prettyprint_var(1, av[i], s);
  1356. X        }
  1357. X        if ((n = fnlookup(av[i])) != NULL) {
  1358. X            f = TRUE;
  1359. X            prettyprint_fn(1, av[i], n);
  1360. X        } else if (isbuiltin(av[i]) != NULL) {
  1361. X            f = TRUE;
  1362. X            for (j = 0; j < arraysize(builtins_str); j++)
  1363. X                if (streq(av[i], builtins_str[j]))
  1364. X                    break;
  1365. X            fprint(1, "builtin %s\n", builtins_str[j]);
  1366. X        } else if ((e = which(av[i], FALSE)) != NULL) {
  1367. X            f = TRUE;
  1368. X            fprint(1, "%s\n", e);
  1369. X        }
  1370. X        if (!f) {
  1371. X            found = FALSE;
  1372. X            if (errno != ENOENT)
  1373. X                uerror(av[i]);
  1374. X            else
  1375. X                fprint(2, "%s not found\n", av[i]);
  1376. X        }
  1377. X    }
  1378. X
  1379. X    set(found);
  1380. }
  1381. X
  1382. /* push a string to be eval'ed onto the input stack. evaluate it */
  1383. X
  1384. static void b_eval(char **av) {
  1385. X    boolean i = interactive;
  1386. X
  1387. X    if (av[1] == NULL)
  1388. X        return;
  1389. X
  1390. X    interactive = FALSE;
  1391. X    pushinput(STRING, av + 1, i); /* don't reset line numbers on noninteractive eval */
  1392. X    doit(TRUE);
  1393. X    interactive = i;
  1394. }
  1395. X
  1396. /*
  1397. X   push a file to be interpreted onto the input stack. with "-i" treat this as an interactive
  1398. X   input source.
  1399. */
  1400. X
  1401. void b_dot(char **av) {
  1402. X    int fd;
  1403. X    boolean old_i = interactive, i = FALSE;
  1404. X    Estack e;
  1405. X
  1406. X    av++;
  1407. X
  1408. X    if (*av == NULL)
  1409. X        return;
  1410. X
  1411. X    if (streq(*av,"-i")) {
  1412. X        av++;
  1413. X        i = TRUE;
  1414. X    }
  1415. X
  1416. X    if (dasheye) { /* rc -i file has to do the right thing. reset the dasheye state to FALSE, though. */
  1417. X        dasheye = FALSE;
  1418. X        i = TRUE;
  1419. X    }
  1420. X
  1421. X    if (*av == NULL)
  1422. X        return;
  1423. X
  1424. X    fd = rc_open(*av, FROM);
  1425. X
  1426. X    if (fd < 0) {
  1427. X        if (rcrc) /* on rc -l, don't flag nonexistence of .rcrc */
  1428. X            rcrc = FALSE;
  1429. X        else
  1430. X            uerror(*av);
  1431. X        set(FALSE);
  1432. X        return;
  1433. X    }
  1434. X    rcrc = FALSE;
  1435. X
  1436. X    starassign(*av, av+1, TRUE);
  1437. X    pushinput(FD, fd);
  1438. X    interactive = i;
  1439. X    except(VARSTACK, "*", &e);
  1440. X    doit(TRUE);
  1441. X    varrm("*", TRUE);
  1442. X    unexcept(); /* VARSTACK */
  1443. X    interactive = old_i;
  1444. }
  1445. X
  1446. /* Berkeley limit support was cleaned up by Paul Haahr. */
  1447. X
  1448. #ifdef NOLIMITS
  1449. static void b_limit(char **av) {
  1450. X    rc_error("rc was compiled without berkeley limits");
  1451. }
  1452. #else
  1453. X
  1454. typedef struct Suffix Suffix;
  1455. struct Suffix {
  1456. X    const Suffix *next;
  1457. X    long amount;
  1458. X    char *name;
  1459. };
  1460. X
  1461. static const Suffix
  1462. X    kbsuf = { NULL, 1024, "k" },
  1463. X    mbsuf = { &kbsuf, 1024*1024, "m" },
  1464. X    gbsuf = { &mbsuf, 1024*1024*1024, "g" },
  1465. X    stsuf = { NULL, 1, "s" },
  1466. X    mtsuf = { &stsuf, 60, "m" },
  1467. X    htsuf = { &mtsuf, 60*60, "h" };
  1468. #define    SIZESUF &gbsuf
  1469. #define    TIMESUF &htsuf
  1470. #define    NOSUF ((Suffix *) NULL)  /* for RLIMIT_NOFILE on SunOS 4.1 */
  1471. X
  1472. typedef struct {
  1473. X    char *name;
  1474. X    int flag;
  1475. X    const Suffix *suffix;
  1476. } Limit;
  1477. static const Limit limits[] = {
  1478. X    { "cputime",        RLIMIT_CPU,    TIMESUF },
  1479. X    { "filesize",        RLIMIT_FSIZE,    SIZESUF },
  1480. X    { "datasize",        RLIMIT_DATA,    SIZESUF },
  1481. X    { "stacksize",        RLIMIT_STACK,    SIZESUF },
  1482. X    { "coredumpsize",    RLIMIT_CORE,    SIZESUF },
  1483. #ifdef RLIMIT_RSS /* SysVr4 does not have this */
  1484. X    { "memoryuse",        RLIMIT_RSS,    SIZESUF },
  1485. #endif
  1486. #ifdef RLIMIT_VMEM /* instead, they have this! */
  1487. X    { "vmemory",        RLIMIT_VMEM,    SIZESUF },
  1488. #endif
  1489. #ifdef RLIMIT_NOFILE  /* SunOS 4.1 adds a limit on file descriptors */
  1490. X    { "descriptors",    RLIMIT_NOFILE,    NOSUF },
  1491. #endif
  1492. X    { NULL, 0, NULL }
  1493. };
  1494. X
  1495. extern int getrlimit(int, struct rlimit *);
  1496. extern int setrlimit(int, struct rlimit *);
  1497. X
  1498. static void printlimit(const Limit *limit, boolean hard) {
  1499. X    struct rlimit rlim;
  1500. X    long lim;
  1501. X    getrlimit(limit->flag, &rlim);
  1502. X    if (hard)
  1503. X        lim = rlim.rlim_max;
  1504. X    else
  1505. X        lim = rlim.rlim_cur;
  1506. X    if (lim == RLIM_INFINITY)
  1507. X        fprint(1, "%s \tunlimited\n", limit->name);
  1508. X    else {
  1509. X        const Suffix *suf;
  1510. X        for (suf = limit->suffix; suf != NULL; suf = suf->next)
  1511. X            if (lim % suf->amount == 0) {
  1512. X                lim /= suf->amount;
  1513. X                break;
  1514. X            }
  1515. X        fprint(1, "%s \t%d%s\n", limit->name, lim, suf == NULL ? "" : suf->name);
  1516. X    }
  1517. }
  1518. X
  1519. static long parselimit(const Limit *limit, char *s) {
  1520. X    int len = strlen(s);
  1521. X    long lim = 1;
  1522. X    const Suffix *suf = limit->suffix;
  1523. X    if (streq(s, "unlimited"))
  1524. X        return RLIM_INFINITY;
  1525. X    if (suf == TIMESUF && strchr(s, ':') != NULL) {
  1526. X        char *t = strchr(s, ':');
  1527. X        *t++ = '\0';
  1528. X        lim = 60 * a2u(s) + a2u(t);
  1529. X    } else {
  1530. X        for (; suf != NULL; suf = suf->next)
  1531. X            if (streq(suf->name, s + len - strlen(suf->name))) {
  1532. X                s[len - strlen(suf->name)] = '\0';
  1533. X                lim *= suf->amount;
  1534. X                break;
  1535. X            }
  1536. X        lim *= a2u(s);
  1537. X    }
  1538. X    return lim;
  1539. }
  1540. X
  1541. static void b_limit(char **av) {
  1542. X    const Limit *lp = limits;
  1543. X    boolean hard = FALSE;
  1544. X
  1545. X    if (*++av != NULL && streq(*av, "-h")) {
  1546. X        av++;
  1547. X        hard = TRUE;
  1548. X    }
  1549. X
  1550. X    if (*av == NULL) {
  1551. X        for (; lp->name != NULL; lp++)
  1552. X            printlimit(lp, hard);
  1553. X        return;
  1554. X    }
  1555. X
  1556. X    for (;; lp++) {
  1557. X        if (lp->name == NULL) {
  1558. X            fprint(2,"no such limit\n");
  1559. X            set(FALSE);
  1560. X            return;
  1561. X        }
  1562. X        if (streq(*av, lp->name))
  1563. X            break;
  1564. X    }
  1565. X
  1566. X    if (*++av == NULL)
  1567. X        printlimit(lp, hard);
  1568. X    else {
  1569. X        struct rlimit rlim;
  1570. X        long pl;
  1571. X        getrlimit(lp->flag, &rlim);
  1572. X        if ((pl = parselimit(lp, *av)) < 0) {
  1573. X            fprint(2,"bad limit\n");
  1574. X            set(FALSE);
  1575. X            return;
  1576. X        }
  1577. X        if (hard)
  1578. X            rlim.rlim_max = pl;
  1579. X        else
  1580. X            rlim.rlim_cur = pl;
  1581. X        if (setrlimit(lp->flag, &rlim) == -1) {
  1582. X            uerror("setrlimit");
  1583. X            set(FALSE);
  1584. X        } else
  1585. X            set(TRUE);
  1586. X    }
  1587. }
  1588. #endif
  1589. SHAR_EOF
  1590. chmod 0644 builtins.c ||
  1591. echo 'restore of builtins.c failed'
  1592. Wc_c="`wc -c < 'builtins.c'`"
  1593. test 11200 -eq "$Wc_c" ||
  1594.     echo 'builtins.c: original size 11200, current size' "$Wc_c"
  1595. rm -f _shar_wnt_.tmp
  1596. fi
  1597. # ============= builtins.h ==============
  1598. if test -f 'builtins.h' -a X"$1" != X"-c"; then
  1599.     echo 'x - skipping builtins.h (File already exists)'
  1600.     rm -f _shar_wnt_.tmp
  1601. else
  1602. > _shar_wnt_.tmp
  1603. echo 'x - extracting builtins.h (Text)'
  1604. sed 's/^X//' << 'SHAR_EOF' > 'builtins.h' &&
  1605. typedef void builtin_t(char **);
  1606. X
  1607. extern builtin_t *isbuiltin(char *);
  1608. extern void b_exec(char **), funcall(char **), b_dot(char **), b_builtin(char **);
  1609. extern char *which(char *, boolean);
  1610. SHAR_EOF
  1611. chmod 0644 builtins.h ||
  1612. echo 'restore of builtins.h failed'
  1613. Wc_c="`wc -c < 'builtins.h'`"
  1614. test 191 -eq "$Wc_c" ||
  1615.     echo 'builtins.h: original size 191, current size' "$Wc_c"
  1616. rm -f _shar_wnt_.tmp
  1617. fi
  1618. # ============= cfix.awk ==============
  1619. if test -f 'cfix.awk' -a X"$1" != X"-c"; then
  1620.     echo 'x - skipping cfix.awk (File already exists)'
  1621.     rm -f _shar_wnt_.tmp
  1622. else
  1623. > _shar_wnt_.tmp
  1624. echo 'x - extracting cfix.awk (Text)'
  1625. sed 's/^X//' << 'SHAR_EOF' > 'cfix.awk' &&
  1626. BEGIN                { Pending = 0; }
  1627. #
  1628. # Special cases.  There are too many, but....
  1629. #
  1630. $0 == "static int (*realgchar)(void);"    {
  1631. X                print "static int (*realgchar)();";
  1632. X                next;
  1633. X                }
  1634. $0 == "static void (*realugchar)(int);"    {
  1635. X                print "static void (*realugchar)();";
  1636. X                next;
  1637. X                }
  1638. $0 == "static void b_break(char **), b_cd(char **)," {
  1639. X                print "static void b_break(), b_cd(),";
  1640. X                next;
  1641. X                }
  1642. $0 == "\tb_echo(char **), b_eval(char **), b_exit(char **), b_limit(char **)," {
  1643. X                print "b_echo(), b_eval(), b_exit(), b_limit(),";
  1644. X                next;
  1645. X                }
  1646. $0 == "\tb_return(char **), b_shift(char **), b_umask(char **), b_wait(char **)," {
  1647. X                print "b_return(), b_shift(), b_umask(), b_wait(),";
  1648. X                next;
  1649. X                }
  1650. $0 == "\tb_whatis(char **);"    {
  1651. X                print "b_whatis();";
  1652. X                next;
  1653. X                }
  1654. $0 == "Node *treecpy(Node *s, void *(*alloc)(SIZE_T)) {" {
  1655. X                print "Node *treecpy(s, alloc)";
  1656. X                printf "Node *s;\nvoid *(*alloc)();\n{\n";
  1657. X                next;
  1658. X                }
  1659. $0 == "\tvoid (*handler)(int);"    {
  1660. X                print "\tvoid (*handler)();";
  1661. X                next;
  1662. X                }
  1663. $0 == "\textern DIR *opendir(const char *);" {
  1664. X                print "#if 0";
  1665. X                print;
  1666. X                next;
  1667. X                }
  1668. $0 == "\textern int closedir(DIR *);" {
  1669. X                print;
  1670. X                print "#endif";
  1671. X                next;
  1672. X                }
  1673. $0 == "\textern int getopt(int, char **, char *);"    {
  1674. X                print "\textern int getopt();";
  1675. X                next;
  1676. X                }
  1677. $0 == "\tstatic void (*vectors[])(char *, List *, boolean) = {"    {
  1678. X                print "\tstatic void (*vectors[])() = {";
  1679. X                next;
  1680. X                }
  1681. $0 == "\t\tvoid (*handler)(int);"    {
  1682. X                print "\t\tvoid (*handler)();";
  1683. X                next;
  1684. X                }
  1685. $0 == "#include <stdarg.h>"    {
  1686. X                print "#include <varargs.h>";
  1687. X                next;
  1688. X                }
  1689. #
  1690. # General cases.
  1691. #
  1692. /^static .*\);$/        {
  1693. X                n = split($0, tmp1, "(");
  1694. X                if (n != 2) {
  1695. X                    print | "sh -c 'cat >&2'";
  1696. X                    print "ERROR with left parens: ", n | "sh -c 'cat >&2'";
  1697. X                    next;
  1698. X                }
  1699. X                printf "%s();\n", tmp1[1];
  1700. X                next;
  1701. X                }
  1702. /^extern .*\);$/        {
  1703. X                n = split($0, tmp1, "(");
  1704. X                if (n != 2) {
  1705. X                    print | "sh -c 'cat >&2'";
  1706. X                    print "ERROR with left parens: ", n | "sh -c 'cat >&2'";
  1707. X                    next;
  1708. X                }
  1709. X                printf "%s();\n", tmp1[1];
  1710. X                next;
  1711. X                }
  1712. /^[a-zA-Z_][a-zA-Z_0-9]*:/    {
  1713. X                print;
  1714. X                next;
  1715. X                }
  1716. /^[^ \t#][^(]*\([^)]*\.\.\.\).*{/ {
  1717. X                if (Pending != 0) {
  1718. X                    print "ERROR: Pending != 0 on function entry" | "sh -c 'cat >&2'";
  1719. X                    next;
  1720. X                }
  1721. X                n = split($0, tmp1, "(");
  1722. X                if (n != 2) {
  1723. X                    print | "sh -c 'cat >&2'";
  1724. X                    print "ERROR with left parens: ", n | "sh -c 'cat >&2'";
  1725. X                    next;
  1726. X                }
  1727. X                n = split(tmp1[2], tmp2, ")");
  1728. X                if (n != 2) {
  1729. X                    print | "sh -c 'cat >&2'";
  1730. X                    print "ERROR with right parens: ", n | "sh -c 'cat >&2'";
  1731. X                    next;
  1732. X                }
  1733. X                printf "%s(va_alist)\nva_dcl\n{\n", tmp1[1];
  1734. X                nargs = split(tmp2[1], args, ",");
  1735. X                for (i = 1; i <= nargs; i++) {
  1736. X                    if (args[i] == "...") {
  1737. X                        if (i == nargs) {
  1738. X                            Pending = 1;
  1739. X                            continue;
  1740. X                        }
  1741. X                        print "ERROR: ... isn't last argument", $0 | "sh -c 'cat >&2'";
  1742. X                        next;
  1743. X                    }
  1744. X                    decls[i] = args[i] ";";
  1745. X                    t = args[i];
  1746. X                    for (;;) {
  1747. X                        n = split(t, varname, " ");
  1748. X                        if (n > 1) {
  1749. X                            t = varname[n];
  1750. X                            continue;
  1751. X                        }
  1752. X                        n = split(t, varname, "*");
  1753. X                        if (n > 1) {
  1754. X                            t = varname[n];
  1755. X                            continue;
  1756. X                        }
  1757. X                        break;
  1758. X                    }
  1759. X                    type = substr(args[i], 1, length(args[i]) - length(t));
  1760. X                    picks[i] = t " = va_arg(ap, " type ");"
  1761. X
  1762. X                }
  1763. X                nargs--;
  1764. X                next;
  1765. X                }
  1766. Pending == 1 && /va_list/    {
  1767. X                for (i = 1; i <= nargs; i++)
  1768. X                    print decls[i];
  1769. X                }
  1770. Pending == 1 && /va_start/    {
  1771. X                n = split($0, tmp1, ",");
  1772. X                if (n != 2) {
  1773. X                    print "ERROR: bad va_start format" | "sh -c 'cat >&2'";
  1774. X                    next;
  1775. X                }
  1776. X                printf "%s);\n", tmp1[1];
  1777. X                for (i = 1; i <= nargs; i++)
  1778. X                    print picks[i];
  1779. X                Pending = 0;
  1780. X                next;
  1781. X                }
  1782. /^[^ \t#][^(]*\([^)]*\).*{/    {
  1783. X                if (Pending != 0) {
  1784. X                    print "ERROR: Pending != 0 on function entry" | "sh -c 'cat >&2'";
  1785. X                    next;
  1786. X                }
  1787. X                n = split($0, tmp1, "(");
  1788. X                if (n != 2) {
  1789. X                    print | "sh -c 'cat >&2'";
  1790. X                    print "ERROR with left parens: ", n | "sh -c 'cat >&2'";
  1791. X                    next;
  1792. X                }
  1793. X                n = split(tmp1[2], tmp2, ")");
  1794. X                if (n != 2) {
  1795. X                    print | "sh -c 'cat >&2'";
  1796. X                    print "ERROR with right parens: ", n | "sh -c 'cat >&2'";
  1797. X                    next;
  1798. X                }
  1799. #                if (tmp2[2] != " {") {
  1800. #                    print "ERROR with last component: `", tmp2[2], "'";
  1801. #                    next;
  1802. #                }
  1803. X                if (tmp2[1] ~ /^[ \t]*void[ \t]*$/ || tmp2[1] ~ /^[ \t]*$/) {
  1804. X                    # no arguments
  1805. X                    printf "%s() {\n\n", tmp1[1];
  1806. X                    next;
  1807. X                }
  1808. X                printf "%s(", tmp1[1];
  1809. X                needcomma = 0;
  1810. X                nargs = split(tmp2[1], args, ",");
  1811. X                for (i = 1; i <= nargs; i++) {
  1812. X                    if (args[i] == "...") {
  1813. X                        print "ERROR: ... shouldn't get here", $0 | "sh -c 'cat >&2'";
  1814. X                        next;
  1815. X                    }
  1816. X                    decls[i] = args[i] ";";
  1817. X                    if (needcomma)
  1818. X                        printf ", ";
  1819. X                    needcomma = 1;
  1820. X                    t = args[i];
  1821. X                    if (t ~ /\[\]$/)
  1822. X                        t = substr(t, 1, length(t) - 2);
  1823. X                    for (;;) {
  1824. X                        n = split(t, varname, " ");
  1825. X                        if (n > 1) {
  1826. X                            t = varname[n];
  1827. X                            continue;
  1828. X                        }
  1829. X                        n = split(t, varname, "*");
  1830. X                        if (n > 1) {
  1831. X                            t = varname[n];
  1832. X                            continue;
  1833. X                        }
  1834. X                        break;
  1835. X                    }
  1836. X                    printf "%s", varname[n];
  1837. X                }
  1838. X                print ")";
  1839. X                for (i = 1; i <= nargs; i++)
  1840. X                    print decls[i];
  1841. X                print "{";
  1842. X                next;
  1843. X                }
  1844. #
  1845. # If we didn't match at all, the line doesn't change.
  1846. #
  1847. X                { print; }
  1848. SHAR_EOF
  1849. chmod 0644 cfix.awk ||
  1850. echo 'restore of cfix.awk failed'
  1851. Wc_c="`wc -c < 'cfix.awk'`"
  1852. test 5252 -eq "$Wc_c" ||
  1853.     echo 'cfix.awk: original size 5252, current size' "$Wc_c"
  1854. rm -f _shar_wnt_.tmp
  1855. fi
  1856. # ============= config.h ==============
  1857. if test -f 'config.h' -a X"$1" != X"-c"; then
  1858.     echo 'x - skipping config.h (File already exists)'
  1859.     rm -f _shar_wnt_.tmp
  1860. else
  1861. > _shar_wnt_.tmp
  1862. echo 'x - extracting config.h (Text)'
  1863. sed 's/^X//' << 'SHAR_EOF' > 'config.h' &&
  1864. /*
  1865. X * Suggested settings for Sun, NeXT and sgi (machines here at TAMU):
  1866. X */
  1867. X
  1868. #ifdef NeXT
  1869. #define NODIRENT
  1870. #define    PROTECT_ENV
  1871. #define PROTECT_JOB
  1872. #define NOCMDARG
  1873. #endif
  1874. X
  1875. #ifdef sgi
  1876. #define NOSIGCLD
  1877. #define    PROTECT_ENV
  1878. #endif
  1879. X
  1880. #ifdef sun
  1881. #define PROTECT_ENV
  1882. #endif
  1883. X
  1884. /*
  1885. X * Suggested settings for HP300 running 4.3BSD-utah (DWS):
  1886. X */
  1887. X
  1888. #if defined(hp300) && !defined(hpux)
  1889. #define NODIRENT
  1890. #define NOCMDARG
  1891. #define DEFAULTINTERP "/bin/sh"
  1892. #define PROTECT_ENV
  1893. #endif
  1894. X
  1895. /*
  1896. X * Suggested settings for Ultrix
  1897. X */
  1898. X
  1899. #ifdef ultrix
  1900. #define PROTECT_ENV
  1901. #endif
  1902. SHAR_EOF
  1903. chmod 0644 config.h ||
  1904. echo 'restore of config.h failed'
  1905. Wc_c="`wc -c < 'config.h'`"
  1906. test 546 -eq "$Wc_c" ||
  1907.     echo 'config.h: original size 546, current size' "$Wc_c"
  1908. rm -f _shar_wnt_.tmp
  1909. fi
  1910. # ============= except.c ==============
  1911. if test -f 'except.c' -a X"$1" != X"-c"; then
  1912.     echo 'x - skipping except.c (File already exists)'
  1913.     rm -f _shar_wnt_.tmp
  1914. else
  1915. > _shar_wnt_.tmp
  1916. echo 'x - extracting except.c (Text)'
  1917. sed 's/^X//' << 'SHAR_EOF' > 'except.c' &&
  1918. #include "jbwrap.h"
  1919. #include <stdarg.h>
  1920. #include "rc.h"
  1921. #include "utils.h"
  1922. #include "except.h"
  1923. #include "status.h"
  1924. #include "hash.h"
  1925. #include "input.h"
  1926. #include "nalloc.h"
  1927. X
  1928. /*
  1929. X   a return goes back stack frames to the last return. A break does not. A signal
  1930. X   goes to the last interactive level.
  1931. */
  1932. X
  1933. static Estack *estack;
  1934. X
  1935. /* add an exception to the input stack. */
  1936. X
  1937. void except(enum except e, void *jb, Estack *ex) {
  1938. X    ex->prev = estack;
  1939. X    estack = ex;
  1940. X
  1941. X    switch (estack->e = e) {
  1942. X    case ARENA:
  1943. X        estack->b = newblock();
  1944. X        break;
  1945. X    case ERROR:
  1946. X    case BREAK:
  1947. X    case RETURN:
  1948. X        estack->interactive = interactive;
  1949. X        estack->jb = (jbwrap *) jb;
  1950. X        break;
  1951. X    case VARSTACK:
  1952. X        estack->name = (char *) jb;
  1953. X        break;
  1954. X    }
  1955. }
  1956. X
  1957. /* remove an exception, restore last interactive value */
  1958. X
  1959. void unexcept() {
  1960. X    if (estack->e == ERROR)
  1961. X        interactive = estack->interactive;
  1962. X    else if (estack->e == ARENA)
  1963. X        restoreblock(estack->b);
  1964. X    estack = estack->prev;
  1965. }
  1966. X
  1967. /*
  1968. X   Raise an exception. The rules are pretty complicated: you can return from a loop inside a
  1969. X   function, but you can't break from a function inside of a loop. On errors, rc_raise() goes back
  1970. X   to the LAST INTERACTIVE stack frame. If no such frame exists, then rc_raise() exits the shell.
  1971. X   This is what happens, say, when there is a syntax error in a noninteractive shell script. While
  1972. X   traversing the exception stack backwards, rc_raise() also removes input sources (closing
  1973. X   file-descriptors, etc.) and pops instances of $* that have been pushed onto the variable stack
  1974. X   (e.g., for a function call).
  1975. */
  1976. X
  1977. void rc_raise(enum except e) {
  1978. X    if (e == ERROR && rc_pid != getpid())
  1979. X            exit(1); /* child processes exit on an error/signal */
  1980. X
  1981. X    for (; estack != NULL; estack = estack->prev)
  1982. X        if (estack->e != e) {
  1983. X            if (e == BREAK && estack->e != ARENA)
  1984. X                rc_error("break outside of loop");
  1985. X            else if (e == RETURN && estack->e == ERROR) /* can return from loops inside functions */
  1986. X                rc_error("return outside of function");
  1987. X            if (estack->e == VARSTACK)
  1988. X                varrm(estack->name, TRUE);
  1989. X            else if (estack->e == ARENA)
  1990. X                restoreblock(estack->b);
  1991. X        } else {
  1992. X            if (e == ERROR && !estack->interactive) {
  1993. X                popinput();
  1994. X            } else {
  1995. X                jbwrap *j = estack->jb;
  1996. X
  1997. X                interactive = estack->interactive;
  1998. X                estack = estack->prev;
  1999. X                longjmp(j->j, 1);
  2000. X            }
  2001. X        }
  2002. X    rc_exit(1); /* top of exception stack */
  2003. }
  2004. SHAR_EOF
  2005. chmod 0644 except.c ||
  2006. echo 'restore of except.c failed'
  2007. Wc_c="`wc -c < 'except.c'`"
  2008. test 2339 -eq "$Wc_c" ||
  2009.     echo 'except.c: original size 2339, current size' "$Wc_c"
  2010. rm -f _shar_wnt_.tmp
  2011. fi
  2012. # ============= except.h ==============
  2013. if test -f 'except.h' -a X"$1" != X"-c"; then
  2014.     echo 'x - skipping except.h (File already exists)'
  2015.     rm -f _shar_wnt_.tmp
  2016. else
  2017. > _shar_wnt_.tmp
  2018. echo 'x - extracting except.h (Text)'
  2019. sed 's/^X//' << 'SHAR_EOF' > 'except.h' &&
  2020. enum except { ERROR, BREAK, RETURN, VARSTACK, ARENA };
  2021. typedef struct Estack Estack;
  2022. X
  2023. struct Estack {
  2024. X    enum except e;
  2025. X    boolean interactive;
  2026. X    jbwrap *jb;
  2027. X    Block *b;
  2028. X    char *name;
  2029. X    Estack *prev;
  2030. };
  2031. X
  2032. extern void rc_raise(enum except);
  2033. extern void except(enum except, void *, Estack *);
  2034. extern void unexcept(void);
  2035. SHAR_EOF
  2036. chmod 0644 except.h ||
  2037. echo 'restore of except.h failed'
  2038. Wc_c="`wc -c < 'except.h'`"
  2039. test 310 -eq "$Wc_c" ||
  2040.     echo 'except.h: original size 310, current size' "$Wc_c"
  2041. rm -f _shar_wnt_.tmp
  2042. fi
  2043. # ============= exec.c ==============
  2044. if test -f 'exec.c' -a X"$1" != X"-c"; then
  2045.     echo 'x - skipping exec.c (File already exists)'
  2046.     rm -f _shar_wnt_.tmp
  2047. else
  2048. > _shar_wnt_.tmp
  2049. echo 'x - extracting exec.c (Text)'
  2050. sed 's/^X//' << 'SHAR_EOF' > 'exec.c' &&
  2051. /*
  2052. X   exec.c: exec() takes an argument list and does the appropriate thing
  2053. X   (calls a builtin, calls a function, etc.)
  2054. */
  2055. X
  2056. #include <signal.h>
  2057. #include <errno.h>
  2058. #include "rc.h"
  2059. #include "utils.h"
  2060. #include "exec.h"
  2061. #include "status.h"
  2062. #include "hash.h"
  2063. #include "builtins.h"
  2064. #include "footobar.h"
  2065. #include "jbwrap.h"
  2066. #include "except.h"
  2067. #include "redir.h"
  2068. #include "wait.h"
  2069. X
  2070. void exec(List *s, boolean parent) {
  2071. X    char **av, **ev;
  2072. X    int pid, stat;
  2073. X    builtin_t *b;
  2074. X    char *path = NULL;
  2075. X    void (*handler)(int);
  2076. X    boolean forked, saw_exec, saw_builtin;
  2077. X
  2078. X    av = list2array(s, dashex);
  2079. X    ev = makeenv();
  2080. X    saw_builtin = saw_exec = FALSE;
  2081. X
  2082. X    do {
  2083. X        if (*av == NULL    || isabsolute(*av))
  2084. X            b = NULL;
  2085. X        else if (!saw_builtin && fnlookup(*av) != NULL)
  2086. X            b = funcall;
  2087. X        else
  2088. X            b = isbuiltin(*av);
  2089. X
  2090. X        saw_builtin = FALSE; /* a builtin applies only to the immmediately following command, e.g., builtin exec echo hi */
  2091. X
  2092. X        if (b == b_exec) {
  2093. X            av++;
  2094. X            saw_exec = TRUE;
  2095. X            parent = FALSE;
  2096. X        } else if (b == b_builtin) {
  2097. X            av++;
  2098. X            saw_builtin = TRUE;
  2099. X        }
  2100. X    } while (b == b_exec || b == b_builtin);
  2101. X
  2102. X    if (*av == NULL && saw_exec) { /* do redirs and return on a null exec */
  2103. X        doredirs();
  2104. X        return;
  2105. X    }
  2106. X
  2107. X    if (b == NULL) {
  2108. X        path = which(*av, TRUE);
  2109. X        if (path == NULL && *av != NULL) { /* perform null commands for redirections */
  2110. X            set(FALSE);
  2111. X            redirq = NULL;
  2112. X            empty_fifoq();
  2113. X            if (parent)
  2114. X                return;
  2115. X            rc_exit(1);
  2116. X        }
  2117. X    }
  2118. X
  2119. X    /* if parent & the redirq is nonnull, builtin or not it has to fork. */
  2120. X
  2121. X    if (parent && (b == NULL || redirq != NULL)) {
  2122. X        pid = rc_fork();
  2123. X        forked = TRUE;
  2124. X    } else {
  2125. X        pid = 0;
  2126. X        forked = FALSE;
  2127. X    }
  2128. X
  2129. X    switch (pid) {
  2130. X    case -1:
  2131. X        uerror("fork");
  2132. X        rc_error(NULL);
  2133. X        /* NOTREACHED */
  2134. X    case 0:
  2135. X        if (forked)
  2136. X            setsigdefaults();
  2137. X        doredirs();
  2138. X
  2139. X        /* null commands performed for redirections */
  2140. X        if (*av == NULL || b != NULL) {
  2141. X            if (b != NULL)
  2142. X                b(av);
  2143. X            empty_fifoq();
  2144. X            if (!forked && parent)
  2145. X                return;
  2146. X            rc_exit(getstatus());
  2147. X        }
  2148. #ifdef NOEXECVE
  2149. X        my_execve(path, (const char **) av, (const char **) ev); /* bogus, huh? */
  2150. #else
  2151. X        execve(path, (const char **) av, (const char **) ev);
  2152. #endif
  2153. #ifdef DEFAULTINTERP
  2154. X        if (errno == ENOEXEC) {
  2155. X            *av = path;
  2156. X            *--av = DEFAULTINTERP;
  2157. X            execve(*av, (const char **) av, (const char **) ev);
  2158. X        }
  2159. #endif
  2160. X        uerror(*av);
  2161. X        rc_exit(1);
  2162. X        /* NOTREACHED */
  2163. X    default:
  2164. X        if ((handler = signal(SIGINT, SIG_IGN)) != sig)
  2165. X            signal(SIGINT, handler); /* don't ignore interrupts in noninteractive mode */
  2166. X        rc_wait4(pid, &stat);
  2167. X        signal(SIGINT, handler);
  2168. X        redirq = NULL;
  2169. X        empty_fifoq();
  2170. X        setstatus(stat);
  2171. X        if (stat == SIGINT || stat == SIGQUIT) /* interrupted? let the handler deal with it. */
  2172. X            rc_raise(ERROR);
  2173. X    }
  2174. }
  2175. SHAR_EOF
  2176. chmod 0644 exec.c ||
  2177. echo 'restore of exec.c failed'
  2178. Wc_c="`wc -c < 'exec.c'`"
  2179. test 2671 -eq "$Wc_c" ||
  2180.     echo 'exec.c: original size 2671, current size' "$Wc_c"
  2181. rm -f _shar_wnt_.tmp
  2182. fi
  2183. # ============= exec.h ==============
  2184. if test -f 'exec.h' -a X"$1" != X"-c"; then
  2185.     echo 'x - skipping exec.h (File already exists)'
  2186.     rm -f _shar_wnt_.tmp
  2187. else
  2188. > _shar_wnt_.tmp
  2189. echo 'x - extracting exec.h (Text)'
  2190. sed 's/^X//' << 'SHAR_EOF' > 'exec.h' &&
  2191. struct Rq {
  2192. X    Node *r;
  2193. X    struct Rq *n;
  2194. };
  2195. X
  2196. extern void exec(List *, boolean);
  2197. extern void doredirs(void);
  2198. SHAR_EOF
  2199. chmod 0644 exec.h ||
  2200. echo 'restore of exec.h failed'
  2201. Wc_c="`wc -c < 'exec.h'`"
  2202. test 104 -eq "$Wc_c" ||
  2203.     echo 'exec.h: original size 104, current size' "$Wc_c"
  2204. rm -f _shar_wnt_.tmp
  2205. fi
  2206. # ============= execve.c ==============
  2207. if test -f 'execve.c' -a X"$1" != X"-c"; then
  2208.     echo 'x - skipping execve.c (File already exists)'
  2209.     rm -f _shar_wnt_.tmp
  2210. else
  2211. > _shar_wnt_.tmp
  2212. echo 'x - extracting execve.c (Text)'
  2213. sed 's/^X//' << 'SHAR_EOF' > 'execve.c' &&
  2214. /* execve.c: an execve() for geriatric unices without #! */
  2215. SHAR_EOF
  2216. true || echo 'restore of execve.c failed'
  2217. fi
  2218. echo 'End of  part 1'
  2219. echo 'File execve.c is continued in part 2'
  2220. echo 2 > _shar_seq_.tmp
  2221. exit 0
  2222. exit 0 # Just in case...
  2223. -- 
  2224. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2225. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2226. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2227. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2228.